package com.whf.android.jar.net.gson;

import android.text.TextUtils;

import androidx.annotation.Nullable;

import com.blankj.utilcode.util.GsonUtils;
import com.blankj.utilcode.util.JsonUtils;
import com.blankj.utilcode.util.RegexUtils;
import com.whf.android.jar.constants.HttpConstant;
import com.whf.android.jar.util.log.LatteLogger;

import java.lang.reflect.Type;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * 解析防止崩溃问题
 *
 * @author qf
 * @version 1.0
 */
public class HttpGsonUtils {

    /**
     * [\\+|-]?：+或-只出现0次或1次
     * \\d+：数字出现一次或多次
     * (.{0}|.\d+)：如果有小数点就必须有小数，否则没有
     * [Ee){1}：存在E或e
     * ([\+|-]?\d+)：正负整数
     */
    public final static String SCIENTIFIC = "^([\\+|-]?\\d+(.{0}|.\\d+))[Ee]{1}([\\+|-]?\\d+)$";

    /**
     * 科学计数 转 String。
     * <p>map数据解析的Object导致大数的科学计数。
     */
    @Nullable
    public static String regexToString(String content) {
        if (TextUtils.isEmpty(content)) {
            return "";
        }
        DecimalFormat df = new DecimalFormat("############.######");
        if (RegexUtils.isMatch(SCIENTIFIC, content)) {
            return df.format(Double.parseDouble(content));
        }
        return content;
    }

    /**
     * Map 转 String。
     * <p>map数据解析的Object导致大数的科学计数。
     */
    @Nullable
    public static String objToString(Map<String, Object> map, String content) {
        if (TextUtils.isEmpty(content)) {
            return "";
        }
        if (map == null) {
            return "";
        }
        return regexToString(map.get(content) + "");
    }

    /**
     * 数据解析
     * <p>map数据解析的Object导致大数的科学计数。
     * <p>HttpGsonUtils.regexToString。
     *
     * @return 解析后的数据
     */
    @Nullable
    public static Map<String, Object> fromJson(String jsonData) {
        return fromJson(jsonData, Map.class);
    }

    /**
     * 数据解析
     *
     * @param type:
     * @return 解析后的数据
     */
    @Nullable
    public static <T> T fromJson(String jsonData, final Type type) {
        try {
            return GsonUtils.fromJson(jsonData, type);
        } catch (Exception e) {
            LatteLogger.e("接口字段类型改了；" + e.getMessage());
            return null;
        }
    }

    /**
     * 数据解析
     *
     * @param jsonData:
     * @return 解析后的数据
     */
    @Nullable
    public static List<Map<String, Object>> fromJsonList(String jsonData) {
        return fromJsonList(jsonData, Map.class);
    }

    /**
     * 数据解析
     *
     * @param type:
     * @return 解析后的数据
     */
    @Nullable
    public static <T> List<T> fromJsonList(String jsonData, final Type type) {
        try {
            return GsonUtils.fromJson(jsonData, GsonUtils.getListType(type));
        } catch (Exception e) {
            LatteLogger.e("接口字段类型改了；" + e.getMessage());
            return new ArrayList<T>();
        }
    }


    /**
     * 数据解析
     *
     * @param type:
     * @return 解析后的数据
     */
    @Nullable
    public static <T> List<List<T>> fromJsonListList(String jsonData, final Type type) {
        try {
            return fromJsonList(jsonData, GsonUtils.getListType(type));
        } catch (Exception e) {
            LatteLogger.e("接口字段类型改了；" + e.getMessage());
            return new ArrayList<List<T>>();
        }
    }

    /**
     * 数据解析(分页)
     *
     * @param jsonData:
     * @return 解析后的数据
     */
    @Nullable
    public static List<Map<String, Object>> fromJsonListRecords(String jsonData) {
        return fromJsonListRecords(jsonData, Map.class);
    }

    /**
     * 数据解析(分页)
     *
     * @param type:
     * @return 解析后的数据
     */
    @Nullable
    public static <T> List<T> fromJsonListRecords(String jsonData, final Type type) {
        try {
            final String records = JsonUtils.getString(jsonData, HttpConstant.RECORDS);
            return GsonUtils.fromJson(records, GsonUtils.getListType(type));
        } catch (Exception e) {
            LatteLogger.e("接口字段类型改了；" + e.getMessage());
            return new ArrayList<T>();
        }
    }


    /**
     * 数据解析(bu分页)
     *
     * @param jsonData:
     * @return 解析后的数据
     */
    @Nullable
    public static List<Map<String, Object>> fromJsonLists(String jsonData) {
        return fromJsonLists(jsonData, Map.class);
    }

    /**
     * 数据解析(bu分页)
     *
     * @param type:
     * @return 解析后的数据
     */
    @Nullable
    public static <T> List<T> fromJsonLists(String jsonData, final Type type) {
        try {
            final String lists = JsonUtils.getString(jsonData, HttpConstant.LIST);
            return GsonUtils.fromJson(lists, GsonUtils.getListType(type));
        } catch (Exception e) {
            LatteLogger.e("接口字段类型改了；" + e.getMessage());
            return new ArrayList<T>();
        }
    }

    public static int getCode(String response) {
        return getInt(response, HttpConstant.CODE);
    }

    public static int getInt(String response, String key) {
        return JsonUtils.getInt(response, key);
    }

    public static String getData(String response) {
        return getString(response, HttpConstant.DATA);
    }

    public static String getString(String response, String key) {
        return JsonUtils.getString(response, key);
    }
}
